// Copyright (c) 2024, BlockProject 3D

//

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without modification,

// are permitted provided that the following conditions are met:

//

//     * Redistributions of source code must retain the above copyright notice,

//       this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above copyright notice,

//       this list of conditions and the following disclaimer in the documentation

//       and/or other materials provided with the distribution.

//     * Neither the name of BlockProject 3D nor the names of its contributors

//       may be used to endorse or promote products derived from this software

//       without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use crate::compiler::message::{Referenced, SizeInfo};

use crate::compiler::structure::{Field, FieldType, FieldView, FixedField, Structure};

use crate::compiler::util::store::name_index;

use crate::compiler::{Error, Protocol};

use crate::model::protocol::Description;

use std::rc::Rc;

#[derive(Clone, Debug)]

pub struct UnionField {

    pub name: String,

    pub description: Option<Description>,

    pub case: usize,

    pub item_type: Option<Referenced>,

}

impl UnionField {

    pub fn from_model(

        proto: &Protocol,

        discriminant: &FixedField,

        value: crate::model::union::UnionField,

    ) -> Result<Self, Error> {

        let case: usize = match &discriminant.view {

            FieldView::Float { .. } => return Err(Error::FloatInUnionDiscriminant),

            FieldView::Enum(r) => {

                r.variants_map.get(&value.case).copied().ok_or(Error::InvalidUnionCase(value.case))
?0
 as usize

            }

            //TODO: Check how unions work with the new bits-type/raw-type/view-type separation

            FieldView::None => value.case.parse().map_err(|_| 
Error::InvalidUnionCase(value.case)0
)
?0
,

        };

        let item_type = value

            .item_type

            .map(|v| 
Referenced::lookup(proto, &v).ok_or(Error::UndefinedReference(v))26
)

            .transpose()
?0
;

        Ok(UnionField {

            name: value.name,

            description: value.description,

            case,

            item_type,

        })

    }

}

#[derive(Clone, Debug)]

pub struct DiscriminantField {

    pub root: Rc<Structure>,

    pub leaf: Rc<Structure>,

    pub leaf_index: usize,

    pub index_list: Vec<usize>,

}

struct DiscriminantFieldIterator<'a> {

    cur: &'a Structure,

    index: std::slice::Iter<'a, usize>,

}

impl<'a> Iterator for DiscriminantFieldIterator<'a> {

    type Item = (&'a Field, bool);

    fn next(&mut self) -> Option<Self::Item> {

        let 
index16
 = self.index.next()
?12
;

        let field = &self.cur.fields[*index];

        let is_leaf = match &field.ty {

            FieldType::Fixed(_) => true,

            FieldType::Array(_) => std::unreachable!(),

            FieldType::Struct(v) => {

                self.cur = v;

                false

            }

        };

        Some((field, is_leaf))

    }

}

impl DiscriminantField {

    pub fn iter(&self) -> impl Iterator<Item = (&Field, bool)> {

        DiscriminantFieldIterator {

            cur: &self.root,

            index: self.index_list.iter(),

        }

    }

    pub fn get_leaf(&self) -> &Field {

        &self.leaf.fields[self.leaf_index]

    }

    pub fn get_leaf_fixed(&self) -> &FixedField {

        self.leaf.fields[self.leaf_index].ty.as_fixed().unwrap()

    }

    pub fn from_model(proto: &Protocol, discriminant: String) -> Result<Self, Error> {

        let mut parts = discriminant.split(".");

        let name = parts.next().ok_or(Error::InvalidUnionDiscriminant)
?0
;

        let mut leaf = proto.structs.get(name).ok_or_else(|| 
Error::UndefinedReference(name.into())0
)
?0
;

        let root = leaf;

        let mut index_list = Vec::new();

        for sub in parts {

            let (index, field) = leaf

                .fields

                .iter()

                .enumerate()

                .find(|(_, v)| v.name == sub)

                .ok_or_else(|| 
Error::UndefinedReference(format!("{}.{}", name, sub))0
)
?0
;

            index_list.push(index);

            match &field.ty {

                FieldType::Fixed(_) => break,

                FieldType::Struct(v) => leaf = v,

                FieldType::Array(_) => return Err(Error::InvalidUnionDiscriminant),

            }

        }

        Ok(DiscriminantField {

            root: root.clone(),

            leaf: leaf.clone(),

            leaf_index: index_list.last().copied().unwrap(),

            index_list,

        })

    }

}

#[derive(Clone, Debug)]

pub struct Union {

    pub name: String,

    pub discriminant: DiscriminantField,

    pub description: Option<Description>,

    pub cases: Vec<UnionField>,

    pub size: SizeInfo,

}

impl Union {

    pub fn has_content(&self) -> bool {

        self.cases.iter().any(|v| v.item_type.is_some())

    }

    pub fn from_model(proto: &Protocol, value: crate::model::union::Union) -> Result<Self, Error> {

        let discriminant = DiscriminantField::from_model(proto, value.discriminant)
?0
;

        let cases = value

            .cases

            .into_iter()

            .map(|v| UnionField::from_model(proto, discriminant.get_leaf_fixed(), v))

            .collect::<Result<Vec<UnionField>, Error>>()
?0
;

        let 
is_element_dyn_sized = cases.iter().any(10
|v| {

            v.item_type

                .as_ref()

                .map(|v| 
match v26
 {

                    Referenced::Struct(_) => false,

                    Referenced::Message(v) => v.size.is_element_dyn_sized,

                
}26
)

                .unwrap_or_default()

        });

        let is_dyn_sized = cases.iter().any(|v| {

            v.item_type

                .as_ref()

                .map(|v| 
match v6
 {

                    Referenced::Struct(_) => false,

                    Referenced::Message(v) => v.size.is_dyn_sized,

                
}6
)

                .unwrap_or_default()

        });

        Ok(Union {

            name: value.name,

            discriminant,

            description: value.description,

            cases,

            size: SizeInfo {

                is_element_dyn_sized,

                is_dyn_sized,

            },

        })

    }

}

name_index!(Union => name);